home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume11 / tgif / patch6.03 < prev    next >
Encoding:
Internet Message Format  |  1991-02-12  |  44.4 KB
  1. Path: uunet!bellcore!att!linac!uwm.edu!lll-winken!sun-barr!newstop!exodus!CS.UCLA.EDU
  2. From: william@CS.UCLA.EDU (William Cheng)
  3. Newsgroups: comp.sources.x
  4. Subject: v11i065: tgif, Patch6, Part03/06
  5. Message-ID: <7935@exodus.Eng.Sun.COM>
  6. Date: 13 Feb 91 07:31:04 GMT
  7. References: <csx-11i063:tgif@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1540
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: william@CS.UCLA.EDU (William Cheng)
  13. Posting-number: Volume 11, Issue 65
  14. Archive-name: tgif/patch6.03
  15. Patch-To: Volume 7, Issue 56-76 (original: tgif-1.2)
  16. Patch-To: Volume 8, Issue 46-48 (Patch1: tgif-1.2 => tgif-1.9)
  17. Patch-To: Volume 8, Issue 58-60 (Patch2: tgif-1.9 => tgif-1.12)
  18. Patch-To: Volume 8, Issue 87-89 (Patch3: tgif-1.12 => tgif-1.13)
  19. Patch-To: Volume 8, Issue 94 (Patch4: tgif-1.13 => tgif-1.14)
  20. Patch-To: Volume 8, Issue 95 (Patch5: tgif-1.14 => tgif-1.15)
  21.  
  22. ---------------------------------> cut here <---------------------------------
  23. *** names.c.orig    Wed Dec 12 14:36:02 1990
  24. --- names.c    Wed Dec 12 14:36:07 1990
  25. ***************
  26. *** 6,10 ****
  27.   #ifndef lint
  28.   static char RCSid[] =
  29. !       "@(#)$Header: /n/kona/u/tangram/u/william/X11/TGIF/RCS/names.c,v 1.6 90/07/27 14:39:29 william Exp $";
  30.   #endif
  31.   
  32. --- 6,10 ----
  33.   #ifndef lint
  34.   static char RCSid[] =
  35. !       "@(#)$Header: /n/kona/u/tangram/u/william/X11/TGIF/RCS/names.c,v 1.18 90/11/09 15:06:52 william Exp $";
  36.   #endif
  37.   
  38. ***************
  39. *** 20,23 ****
  40. --- 20,24 ----
  41.   #include "button.e"
  42.   #include "cursor.e"
  43. + #include "file.e"
  44.   #include "font.e"
  45.   #include "mainloop.e"
  46. ***************
  47. *** 33,37 ****
  48. --- 34,50 ----
  49.   #define ROW_HEIGHT (defaultFontHeight+1)
  50.   
  51. + typedef struct _DspList {
  52. +    char            itemstr[MAXPATHLENGTH+1];
  53. +    char            pathstr[MAXPATHLENGTH+1];
  54. +    int            directory;
  55. +    struct _DspList    * next;
  56. + } DspList;
  57. + 
  58. + extern char    * getenv ();
  59. + 
  60.   char    curDomainName[MAXPATHLENGTH];
  61. + char    curDomainPath[MAXPATHLENGTH];
  62. + char    curDir[MAXPATHLENGTH];
  63. + char    curSymDir[MAXPATHLENGTH];
  64.   
  65.   static Window        nameBaseWin;
  66. ***************
  67. *** 55,61 ****
  68.   static GC    revNameGC;
  69.   
  70.   void InitNames ()
  71.   {
  72. !    char        * c_ptr;
  73.      XGCValues    values;
  74.   
  75. --- 68,343 ----
  76.   static GC    revNameGC;
  77.   
  78. + static DspList    * symbolList = NULL;
  79. + static int    numSymbols;
  80. + static DspList    * dirList = NULL;
  81. + static int    numDirEntries;
  82. + 
  83. + static DspList    * topOfSymLinkList = NULL;
  84. + static DspList    * topOfDirLinkList = NULL;
  85. + 
  86. + static
  87. + char * ReadPath (path_str, dir_str)
  88. +    char * path_str, * dir_str;
  89. + {
  90. +    register char        * s1, * s2;
  91. + 
  92. +    s1 = path_str;
  93. +    if (*s1 == '~')
  94. +    {
  95. +       strcpy (dir_str, homeDir);
  96. +       s2 = &dir_str[strlen(dir_str)];
  97. +       s1++;
  98. +    }
  99. +    else
  100. +       s2 = dir_str;
  101. + 
  102. +    for ( ; *s1 != '\0' && *s1 != ':'; s1++)
  103. +       if (*s1 == '\\')
  104. +          strcpy (s1, s1+1);
  105. +       else
  106. +          *s2++ = *s1;
  107. + 
  108. +    *s2 = '\0';
  109. +    if (*s1 == ':') s1++;
  110. +    return (s1);
  111. + }
  112. + 
  113. + void ParseSymPath (path_str)
  114. +    char * path_str;
  115. + {
  116. +    register char        * s, c;
  117. +    register int         i;
  118. +    char                 dir_str[MAXPATHLENGTH];
  119. + 
  120. +    for (i = 0, s = path_str; *s != '\0'; )
  121. +    {
  122. +       s = ReadPath (s, dir_str);
  123. +       if (dir_str != '\0') i++;
  124. +    }
  125. +    symPath = (char * *) calloc (i, sizeof (char *));
  126. +    symPathNumEntries = i;
  127. +    for (i = 0, s = path_str; *s != '\0'; )
  128. +    {
  129. +       s = ReadPath (s, dir_str);
  130. +       if (dir_str != '\0')
  131. +       {
  132. +          symPath[i] = (char *) calloc (MAXPATHLENGTH, sizeof (char));
  133. +          strcpy (symPath[i], dir_str);
  134. +          i++;
  135. +       }
  136. +    }
  137. +    strcpy (curDomainPath, path_str);
  138. + }
  139. + 
  140. + static
  141. + DspList * SymbolListing ()
  142. + {
  143. +    int            i, len, path_index, count = 0, reject;
  144. +    char            path[MAXPATHLENGTH], s[MAXPATHLENGTH];
  145. +    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  146. +    DIR            * dirp;
  147. +    struct direct    * d;
  148. +    struct stat        stat_buf;
  149. + 
  150. +    head_ptr = tail_ptr = NULL;
  151. +    for (path_index = 0; path_index < symPathNumEntries; path_index++)
  152. +    {
  153. +       strcpy (path, symPath[path_index]);
  154. +       if (strcmp (".", path) == 0) strcpy (path, curDir);
  155. + 
  156. +       if ((dirp = opendir (path)) == NULL)
  157. +          continue;
  158. + 
  159. +       while ((d = readdir (dirp)) != NULL)
  160. +       {
  161. +          len = strlen (d->d_name);
  162. +          if (len > 4 && (strcmp (".sym", &d->d_name[len-4]) == 0))
  163. +             d->d_name[len-4] = '\0';
  164. +          else
  165. +             continue;
  166. + 
  167. +          if (head_ptr == NULL)
  168. +          {
  169. +             head_ptr = tail_ptr = (DspList *) calloc (1, sizeof(DspList));
  170. +             strcpy (head_ptr->itemstr, d->d_name);
  171. +             strcpy (head_ptr->pathstr, path);
  172. +          }
  173. +          else
  174. +          {
  175. +             p1 = NULL;
  176. +             reject = FALSE;
  177. +             for (p = head_ptr; p != NULL; p = p->next)
  178. +             {
  179. +                if (strcmp (d->d_name, p->itemstr) == 0)
  180. +                {
  181. +                   reject = TRUE;
  182. +                   break;
  183. +                }
  184. +                else if (LargerStr (d->d_name, p->itemstr))
  185. +                   p1 = p;
  186. +                else
  187. +                {
  188. +                   dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  189. +                   strcpy (dsp_ptr->itemstr, d->d_name);
  190. +                   strcpy (dsp_ptr->pathstr, path);
  191. +                   break;
  192. +                }
  193. +             }
  194. +             if (reject) continue;
  195. +    
  196. +             dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  197. +             dsp_ptr->next = p;
  198. +             strcpy (dsp_ptr->itemstr, d->d_name);
  199. +             strcpy (dsp_ptr->pathstr, path);
  200. + 
  201. +             if (p == NULL)
  202. +             {  /* dsp_ptr has the largest element */
  203. +                tail_ptr->next = dsp_ptr;
  204. +                tail_ptr = dsp_ptr;
  205. +             }
  206. +             else if (p1 == NULL)
  207. +                head_ptr = dsp_ptr;
  208. +             else
  209. +                p1->next = dsp_ptr;
  210. +          }
  211. +          count++;
  212. +       }
  213. +       closedir (dirp);
  214. +    }
  215. +    numSymbols = count;
  216. +    return (head_ptr);
  217. + }
  218. + 
  219. + static
  220. + void BuildSymbolList ()
  221. + {
  222. +    register int        i;
  223. +    register DspList    * dsp_ptr;
  224. + 
  225. +    if (symbolList != NULL) cfree (symbolList);
  226. + 
  227. +    symbolList = (DspList *) calloc (numSymbols, sizeof (DspList));
  228. +    dsp_ptr = topOfSymLinkList;
  229. +    for (i = 0; i < numSymbols; i++, dsp_ptr = dsp_ptr->next)
  230. +    {
  231. +       strcpy (symbolList[i].itemstr, dsp_ptr->itemstr);
  232. +       strcpy (symbolList[i].pathstr, dsp_ptr->pathstr);
  233. +       symbolList[i].next = &symbolList[i+1];
  234. +       cfree (dsp_ptr);
  235. +    }
  236. +    symbolList[numSymbols-1].next = NULL;
  237. +    topOfSymLinkList = NULL;
  238. + }
  239. + 
  240. + static
  241. + DspList * DirListing (Path)
  242. +    char    * Path;
  243. + {
  244. +    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  245. +    DIR            * dirp;
  246. +    struct direct    * d;
  247. +    int            len, count = 0;
  248. +    char            path[MAXPATHLENGTH], s[MAXPATHLENGTH];
  249. +    struct stat        stat_buf;
  250. + 
  251. +    if (*Path == '\0')
  252. +    {
  253. +       strcpy (path, "/");
  254. +       if ((dirp = opendir (path)) == NULL) return (NULL);
  255. +    }
  256. +    else
  257. +    {
  258. +       strcpy (path, Path);
  259. +       if ((dirp = opendir (path)) == NULL) return (NULL);
  260. +       strcat (path, "/");
  261. +    }
  262. + 
  263. +    head_ptr = tail_ptr = NULL;
  264. + 
  265. +    while ((d = readdir (dirp)) != NULL)
  266. +    {
  267. +       len = strlen (d->d_name);
  268. +       if (len > 4 && (strcmp (".obj", &d->d_name[len-4]) == 0))
  269. +       {
  270. +          d->d_name[len-4] = '\0';
  271. +          dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  272. +          dsp_ptr->directory = FALSE;
  273. +          strcpy (dsp_ptr->itemstr, d->d_name);
  274. +       }
  275. +       else if (strcmp (d->d_name, ".") == 0)
  276. +          continue;
  277. +       else
  278. +       {
  279. +          sprintf (s, "%s%s", path, d->d_name);
  280. +          stat (s, &stat_buf);
  281. +          if (stat_buf.st_mode & S_IFDIR)
  282. +          {
  283. +             dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  284. +             dsp_ptr->directory = TRUE;
  285. +             strcat (d->d_name, "/");
  286. +             strcpy (dsp_ptr->itemstr, d->d_name);
  287. +          }
  288. +          else
  289. +             continue;
  290. +       }
  291. +       if (head_ptr == NULL)
  292. +          head_ptr = tail_ptr = dsp_ptr;
  293. +       else
  294. +       {
  295. +          p1 = NULL;
  296. +          for (p = head_ptr; p != NULL; p = p->next)
  297. +             if (LargerStr (d->d_name, p->itemstr))
  298. +                p1 = p;
  299. +             else
  300. +                break;
  301. + 
  302. +          dsp_ptr->next = p;
  303. +          if (p == NULL)
  304. +          {  /* dsp_ptr has the largest element */
  305. +             tail_ptr->next = dsp_ptr;
  306. +             tail_ptr = dsp_ptr;
  307. +          }
  308. +          else if (p1 == NULL)
  309. +             head_ptr = dsp_ptr;
  310. +          else
  311. +             p1->next = dsp_ptr;
  312. +       }
  313. +       count++;
  314. +    }
  315. + 
  316. +    closedir (dirp);
  317. +    numDirEntries = count;
  318. +    return (head_ptr);
  319. + }
  320. + 
  321. + static
  322. + void BuildDirList ()
  323. + {
  324. +    register int        i;
  325. +    register DspList    * dsp_ptr;
  326. + 
  327. +    if (topOfDirLinkList != NULL)
  328. +    {
  329. +       if (dirList != NULL) cfree (dirList);
  330. + 
  331. +       dirList = (DspList *) calloc (numDirEntries, sizeof (DspList));
  332. +       dsp_ptr = topOfDirLinkList;
  333. +       for (i = 0; i < numDirEntries; i++, dsp_ptr = dsp_ptr->next)
  334. +       {
  335. +          strcpy (dirList[i].itemstr, dsp_ptr->itemstr);
  336. +          strcpy (dirList[i].pathstr, dsp_ptr->pathstr);
  337. +          dirList[i].directory = dsp_ptr->directory;
  338. +          dirList[i].next = &dirList[i+1];
  339. +          cfree (dsp_ptr);
  340. +       }
  341. +       dirList[numDirEntries-1].next = NULL;
  342. +       topOfDirLinkList = NULL;
  343. +    }
  344. + }
  345. + 
  346.   void InitNames ()
  347.   {
  348. !    int        default_found = FALSE;
  349. !    char        * c_ptr, domain_str[20], sym_path[80];
  350.      XGCValues    values;
  351.   
  352. ***************
  353. *** 79,82 ****
  354. --- 361,367 ----
  355.   
  356.      *curDomainName = '\0';
  357. +    *curDomainPath = '\0';
  358. +    *curSymDir = '\0';
  359. +    strcpy (curDir, bootDir);
  360.   
  361.      if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, "DoubleClickInterval")) !=
  362. ***************
  363. *** 85,90 ****
  364. --- 370,408 ----
  365.      else
  366.         doubleClickInterval = 300;
  367. + 
  368. +    if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, "DefaultDomain")) != NULL)
  369. +    {
  370. +       sprintf (domain_str, "Domain%s", c_ptr);
  371. +       if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, domain_str)) != NULL)
  372. +       {
  373. +          if (*c_ptr != '\0')
  374. +          {
  375. +             strcpy (curDomainName, c_ptr);
  376. +             sprintf (sym_path, "TGIF_%s", c_ptr);
  377. +             default_found = TRUE;
  378. +          }
  379. +       }
  380. +    }
  381. + 
  382. +    if (!default_found || (c_ptr = getenv (sym_path)) == NULL)
  383. +       ParseSymPath (".");
  384. +    else
  385. +       if (strlen (c_ptr) >= MAXPATHLENGTH-1)
  386. +          ParseSymPath (".");
  387. +       else 
  388. +          ParseSymPath (c_ptr);
  389. +    if ((topOfSymLinkList = SymbolListing ()) != NULL) BuildSymbolList ();
  390.   }
  391.   
  392. + void UpdateDirInfo ()
  393. + {
  394. +    if ((topOfDirLinkList = DirListing (curDir)) != NULL) BuildDirList ();
  395. + }
  396. + 
  397. + void UpdateSymInfo ()
  398. + {
  399. +    if ((topOfSymLinkList = SymbolListing ()) != NULL) BuildSymbolList ();
  400. + }
  401. + 
  402.   void CleanUpNames ()
  403.   {
  404. ***************
  405. *** 91,94 ****
  406. --- 409,415 ----
  407.      XFreeGC (mainDisplay, nameGC);
  408.      XFreeGC (mainDisplay, revNameGC);
  409. + 
  410. +    if (symbolList != NULL) cfree (symbolList);
  411. +    if (dirList != NULL) cfree (dirList);
  412.   }
  413.   
  414. ***************
  415. *** 145,149 ****
  416.      register int    i;
  417.      int        top, len, end, pixel;
  418. -    DspItem    * diptr;
  419.      XGCValues    values;
  420.   
  421. --- 466,469 ----
  422. ***************
  423. *** 181,188 ****
  424.   
  425.   static
  426. ! void RedrawNameBaseWindow (Str, str_start, button_start, W, H)
  427. !    char    * Str;
  428. !    int    str_start, button_start;
  429.   {
  430.      int    top = defaultFontAsc+2;
  431.   
  432. --- 501,537 ----
  433.   
  434.   static
  435. ! void RedrawNamePath (Path, X, Y)
  436. !    char    * Path;
  437. !    int    X, Y;
  438.   {
  439. +    int    len = strlen (Path), cursor_x, cursor_y;
  440. +    char    * c_ptr;
  441. + 
  442. +    cursor_y = Y-defaultFontAsc;
  443. + 
  444. +    XClearArea (mainDisplay, nameBaseWin, X, Y-defaultFontAsc,
  445. +          ITEM_LEN*defaultFontWidth+4, defaultFontHeight+4, False);
  446. +    XDrawRectangle (mainDisplay, nameBaseWin, nameGC, X, cursor_y-2,
  447. +          ITEM_LEN*defaultFontWidth+8, defaultFontHeight+4);
  448. + 
  449. +    if (len > ITEM_LEN)
  450. +    {
  451. +       c_ptr = &(Path[len-ITEM_LEN]);
  452. +       len = ITEM_LEN;
  453. +    }
  454. +    else
  455. +       c_ptr = Path;
  456. + 
  457. +    cursor_x = X+2+len*defaultFontWidth;
  458. +    XDrawString (mainDisplay, nameBaseWin, nameGC, X+2, Y, c_ptr, len);
  459. +    XDrawLine (mainDisplay, nameBaseWin, nameGC, cursor_x,
  460. +          cursor_y, cursor_x, cursor_y+defaultFontHeight);
  461. + }
  462. + 
  463. + static
  464. + void RedrawNameBaseWindow (Str, Path, str_start, path_start, button_start, W, H)
  465. +    char    * Str, * Path;
  466. +    int    str_start, path_start, button_start, W, H;
  467. + {
  468.      int    top = defaultFontAsc+2;
  469.   
  470. ***************
  471. *** 190,199 ****
  472.      XDrawString (mainDisplay, nameBaseWin, nameGC, str_start,
  473.            ROW_HEIGHT+top, Str, strlen(Str));
  474.   
  475. !    buttonBBox[0].lty = buttonBBox[1].lty = (ITEM_DSPED+4) * ROW_HEIGHT;
  476.      buttonBBox[0].ltx = button_start;
  477. !    DisplayButton (nameBaseWin, "OK", 8, &buttonBBox[0], BUTTON_NORMAL);
  478.      buttonBBox[1].ltx = buttonBBox[CONFIRM_YES].rbx + 1 + defaultFontWidth;
  479. !    DisplayButton (nameBaseWin, "CANCEL", 8, &buttonBBox[1],
  480.            BUTTON_NORMAL);
  481.   }
  482. --- 539,549 ----
  483.      XDrawString (mainDisplay, nameBaseWin, nameGC, str_start,
  484.            ROW_HEIGHT+top, Str, strlen(Str));
  485. +    RedrawNamePath (Path, path_start, 3*ROW_HEIGHT+top);
  486.   
  487. !    buttonBBox[0].lty = buttonBBox[1].lty = (ITEM_DSPED+6) * ROW_HEIGHT;
  488.      buttonBBox[0].ltx = button_start;
  489. !    DisplayButton (nameBaseWin, "OK", 8, &(buttonBBox[0]), BUTTON_NORMAL);
  490.      buttonBBox[1].ltx = buttonBBox[CONFIRM_YES].rbx + 1 + defaultFontWidth;
  491. !    DisplayButton (nameBaseWin, "CANCEL", 8, &(buttonBBox[1]),
  492.            BUTTON_NORMAL);
  493.   }
  494. ***************
  495. *** 213,221 ****
  496.         dsp_ptr[i] = c_ptr;
  497.         len = strlen (DLPtr->itemstr);
  498. !       for (j = len; j >= 0 && DLPtr->itemstr[j] != '/'; j--) ;
  499. !       if (j >= 0)
  500. !          strcpy (c_ptr, (&DLPtr->itemstr[j])+1);
  501.         else
  502.            strcpy (c_ptr, DLPtr->itemstr);
  503.         c_ptr += MAXPATHLENGTH;
  504.      }
  505. --- 563,577 ----
  506.         dsp_ptr[i] = c_ptr;
  507.         len = strlen (DLPtr->itemstr);
  508. !       if (!DLPtr->directory)
  509. !       {
  510. !          for (j = len; j >= 0 && DLPtr->itemstr[j] != '/'; j--) ;
  511. !          if (j >= 0)
  512. !             strcpy (c_ptr, (&(DLPtr->itemstr[j]))+1);
  513. !          else
  514. !             strcpy (c_ptr, DLPtr->itemstr);
  515. !       }
  516.         else
  517.            strcpy (c_ptr, DLPtr->itemstr);
  518. + 
  519.         c_ptr += MAXPATHLENGTH;
  520.      }
  521. ***************
  522. *** 343,362 ****
  523.   
  524.   static
  525. ! int Names (Str)
  526. !    char    * Str;
  527.   {
  528. !    int        x, y, pixel, button_widths, str_width, graph_width, w, h;
  529. !    int        str_start, button_start, graph_start, index;
  530. !    int        dsp_w, dsp_h;
  531. !    XEvent    input, ev;
  532. !    int        i, len, looping = TRUE, grabbed = FALSE;
  533. !    char        buf[80];
  534. !    XKeyEvent    * key_ev;
  535. !    XButtonEvent    * button_ev;
  536. !    KeySym    key_sym;
  537.      XComposeStatus    c_stat;
  538.      XSetWindowAttributes    win_attrs;
  539. !    int        win_x, win_y, win_w, win_h, win_d, win_brdr_w;
  540. !    Window    root_win;
  541.   
  542.      dsp_w = DisplayWidth (mainDisplay, mainScreen);
  543. --- 699,730 ----
  544.   
  545.   static
  546. ! int LargerStr (S1, S2)
  547. !    register char    * S1, * S2;
  548. !    /* returns TRUE if S1 > S2 */
  549.   {
  550. !    while (*S1 == *S2 && *S1 != '\0' && *S2 != '\0') { S1++; S2++; }
  551. ! 
  552. !    return (*S1 > *S2);
  553. ! }
  554. ! 
  555. ! static
  556. ! int DirNames (TopStr, SelStr)
  557. !    char    * TopStr, * SelStr;
  558. ! {
  559. !    int            pixel, button_widths, str_width, graph_width;
  560. !    int            str_start, button_start, graph_start, index;
  561. !    int            dsp_w, dsp_h, x, y, w, h, i, len, exposure = 0;
  562. !    XEvent        input, ev;
  563. !    int            looping = TRUE, changing, grabbed = FALSE, name_index;
  564. !    char            buf[80], name[MAXPATHLENGTH], full_name[MAXPATHLENGTH];
  565. !    char            dir_name[MAXPATHLENGTH], sel_str[MAXPATHLENGTH];
  566. !    XKeyEvent        * key_ev;
  567. !    XButtonEvent        * button_ev;
  568. !    KeySym        key_sym;
  569.      XComposeStatus    c_stat;
  570.      XSetWindowAttributes    win_attrs;
  571. !    int            win_x, win_y, win_w, win_h, win_d, win_brdr_w;
  572. !    Window        root_win;
  573. !    DspList        * dsp_ptr, * head_dsp_ptr;
  574.   
  575.      dsp_w = DisplayWidth (mainDisplay, mainScreen);
  576. ***************
  577. *** 365,369 ****
  578.      button_widths = ButtonWidth("OK", 8) + ButtonWidth("CANCEL", 8) +
  579.            defaultFontWidth;
  580. !    str_width = defaultFontWidth * strlen (Str);
  581.      graph_width = nameDspWinW + scrollBarW + 2 * brdrW;
  582.   
  583. --- 733,737 ----
  584.      button_widths = ButtonWidth("OK", 8) + ButtonWidth("CANCEL", 8) +
  585.            defaultFontWidth;
  586. !    str_width = defaultFontWidth * strlen (TopStr);
  587.      graph_width = nameDspWinW + scrollBarW + 2 * brdrW;
  588.   
  589. ***************
  590. *** 381,385 ****
  591.      }
  592.      button_start = (w - button_widths) / 2;
  593. !    h = (6 + ITEM_DSPED) * ROW_HEIGHT;
  594.   
  595.      win_x = (w > dsp_w) ? 0 : (dsp_w - w)/2;
  596. --- 749,753 ----
  597.      }
  598.      button_start = (w - button_widths) / 2;
  599. !    h = (8 + ITEM_DSPED) * ROW_HEIGHT;
  600.   
  601.      win_x = (w > dsp_w) ? 0 : (dsp_w - w)/2;
  602. ***************
  603. *** 393,397 ****
  604.   
  605.      if ((nameDspWin = XCreateSimpleWindow (mainDisplay, nameBaseWin, graph_start,
  606. !          3*ROW_HEIGHT, nameDspW, nameDspH, brdrW, myBorderPixel,
  607.            myBgPixel)) == 0)
  608.      { printf ("Could not create desired popup window!\n"); exit (-1); }
  609. --- 761,765 ----
  610.   
  611.      if ((nameDspWin = XCreateSimpleWindow (mainDisplay, nameBaseWin, graph_start,
  612. !          5*ROW_HEIGHT, nameDspW, nameDspH, brdrW, myBorderPixel,
  613.            myBgPixel)) == 0)
  614.      { printf ("Could not create desired popup window!\n"); exit (-1); }
  615. ***************
  616. *** 398,402 ****
  617.   
  618.      if ((nameScrollWin = XCreateSimpleWindow (mainDisplay, nameBaseWin,
  619. !          graph_start+nameDspWinW, 3*ROW_HEIGHT, scrollBarW, nameDspH,
  620.            brdrW, myBorderPixel, myBgPixel)) == 0)
  621.      { printf ("Could not create desired popup scroll window!\n"); exit (-1); }
  622. --- 766,770 ----
  623.   
  624.      if ((nameScrollWin = XCreateSimpleWindow (mainDisplay, nameBaseWin,
  625. !          graph_start+nameDspWinW, 5*ROW_HEIGHT, scrollBarW, nameDspH,
  626.            brdrW, myBorderPixel, myBgPixel)) == 0)
  627.      { printf ("Could not create desired popup scroll window!\n"); exit (-1); }
  628. ***************
  629. *** 419,425 ****
  630. --- 787,1122 ----
  631.            KeyPressMask | ButtonPressMask | ExposureMask);
  632.   
  633. +    strcpy (dir_name, curDir);
  634. + 
  635.      justClicked = FALSE;
  636.      while (looping)
  637.      {
  638. +       nameEntries = numDirEntries;
  639. +       if (topOfDirLinkList == NULL)
  640. +          nameDspPtr = MakeNameDspItemArray (nameEntries, dirList);
  641. +       else
  642. +          nameDspPtr = MakeNameDspItemArray (nameEntries, topOfDirLinkList);
  643. +       nameFirst = 0;
  644. +       nameMarked = 0;
  645. + 
  646. +       sprintf (full_name, "%s/", dir_name);
  647. +       name[0] = '\0';
  648. +       name_index = 0;
  649. + 
  650. +       if (exposure >= 3)
  651. +       {
  652. +          XClearWindow (mainDisplay, nameBaseWin);
  653. +          XClearWindow (mainDisplay, nameDspWin);
  654. +          XClearWindow (mainDisplay, nameScrollWin);
  655. +          RedrawNameBaseWindow (TopStr, full_name, str_start, graph_start,
  656. +                button_start, w, h);
  657. +          RedrawNameScrollWin ();
  658. +          RedrawDspWindow ();
  659. +       }
  660. + 
  661. +       changing = TRUE;
  662. +       while (changing)
  663. +       {
  664. +          XNextEvent (mainDisplay, &input);
  665. +          if (input.type == Expose)
  666. +          {
  667. +             if (input.xany.window == nameBaseWin)
  668. +             {
  669. +                RedrawNameBaseWindow (TopStr, full_name, str_start, graph_start,
  670. +                      button_start, w, h);
  671. +                exposure++;
  672. +             }
  673. +             else if (input.xany.window == nameScrollWin)
  674. +             {
  675. +                RedrawNameScrollWin ();
  676. +                exposure++;
  677. +             }
  678. +             else if (input.xany.window == nameDspWin)
  679. +             {
  680. +                RedrawDspWindow ();
  681. +                exposure++;
  682. +             }
  683. + 
  684. +             if (!grabbed)
  685. +             {
  686. +                XGrabKeyboard (mainDisplay, nameBaseWin, False,
  687. +                      GrabModeAsync, GrabModeAsync, CurrentTime);
  688. +                grabbed = TRUE;
  689. +             }
  690. + 
  691. +             continue;
  692. +          }
  693. +          else if (input.type == KeyPress)
  694. +          {
  695. +             key_ev = &(input.xkey);
  696. +             XLookupString (key_ev, buf, 80, &key_sym, &c_stat);
  697. + 
  698. +             if ((buf[0]=='\r' && (key_sym & 0xff)=='\r') ||
  699. +                 (buf[0]=='\n' && (key_sym & 0xff)=='\n'))
  700. +             {
  701. +                changing = FALSE;
  702. +                index = nameMarked;
  703. +             }
  704. +             else if (buf[0]=='\033' && (key_sym & 0xff)=='\033')
  705. +             {
  706. +                looping = FALSE;
  707. +                changing = FALSE;
  708. +                index = INVALID;
  709. +             }
  710. +             else if (buf[0] == '\b' || buf[0] == '\177')
  711. +             {
  712. +                if (name_index != 0)
  713. +                {
  714. +                   name[--name_index] = '\0';
  715. +                   sprintf (full_name, "%s/%s", dir_name, name);
  716. +                   for (i = 0; i < nameEntries; i++)
  717. +                      if (strncmp (nameDspPtr[i], name, name_index) == 0)
  718. +                         break;
  719. + 
  720. +                   if (i < nameEntries)
  721. +                   {
  722. +                      if (i < nameFirst)
  723. +                         nameFirst = i;
  724. +                      else if (i >= nameFirst+ITEM_DSPED)
  725. +                      {
  726. +                         if (i < nameEntries-ITEM_DSPED)
  727. +                            nameFirst = i;
  728. +                         else
  729. +                            nameFirst = nameEntries-ITEM_DSPED;
  730. +                      }
  731. +                      nameMarked = i;
  732. +                      RedrawNamePath (full_name, graph_start,
  733. +                            3*ROW_HEIGHT+defaultFontAsc+2);
  734. +                      RedrawNameScrollWin ();
  735. +                      RedrawDspWindow ();
  736. +                   }
  737. +                }
  738. +             }
  739. +             else if (key_sym>='\040' && key_sym<='\177')
  740. +             {
  741. +                if (buf[0] == '$')
  742. +                {
  743. +                   i = (nameEntries == 0) ? 0 : nameEntries-1;
  744. +                   strcpy (name, nameDspPtr[i]);
  745. +                }
  746. +                else
  747. +                {
  748. +                   name[name_index++] = buf[0];
  749. +                   name[name_index] = '\0';
  750. +                   for (i = 0; i < nameEntries; i++)
  751. +                      if (strncmp (nameDspPtr[i], name, name_index) == 0)
  752. +                         break;
  753. +                }
  754. + 
  755. +                if (i < nameEntries)
  756. +                {
  757. +                   if (buf[0] == '/')
  758. +                   {
  759. +                      changing = FALSE;
  760. +                      index = nameMarked = i;
  761. +                   }
  762. +                   else
  763. +                   {
  764. +                      if (i < nameFirst)
  765. +                         nameFirst = i;
  766. +                      else if (i >= nameFirst+ITEM_DSPED)
  767. +                      {
  768. +                         if (i < nameEntries-ITEM_DSPED)
  769. +                            nameFirst = i;
  770. +                         else
  771. +                            nameFirst = nameEntries-ITEM_DSPED;
  772. +                      }
  773. +                      nameMarked = i;
  774. + 
  775. +                      sprintf (full_name, "%s/%s", dir_name, name);
  776. +                      RedrawNamePath (full_name, graph_start,
  777. +                            3*ROW_HEIGHT+defaultFontAsc+2);
  778. +                      RedrawNameScrollWin ();
  779. +                      RedrawDspWindow ();
  780. +                   }
  781. +                }
  782. +                else
  783. +                   name[--name_index] = '\0';
  784. +             }
  785. +          }
  786. +          else if (input.type == ButtonPress)
  787. +          {
  788. +             button_ev = &(input.xbutton);
  789. +             if (button_ev->window == nameBaseWin)
  790. +             {
  791. +                if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[0]))
  792. +                {
  793. +                   changing = FALSE;
  794. +                   index = nameMarked;
  795. +                }
  796. +                else if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[1]))
  797. +                {
  798. +                   looping = FALSE;
  799. +                   changing = FALSE;
  800. +                   index = INVALID;
  801. +                }
  802. +             }
  803. +             else if (button_ev->window == nameScrollWin)
  804. +                NameScrollHandler (button_ev);
  805. +             else if (button_ev->window == nameDspWin)
  806. +             {
  807. +                if (NameDspHandler (button_ev) != INVALID)
  808. +                {
  809. +                   changing = FALSE;
  810. +                   index = nameMarked;
  811. +                }
  812. +                else if (nameMarked != INVALID)
  813. +                {
  814. +                   strcpy (name, nameDspPtr[nameMarked]);
  815. +                   sprintf (full_name, "%s/%s", dir_name, name);
  816. +                   RedrawNamePath (full_name, graph_start,
  817. +                         3*ROW_HEIGHT+defaultFontAsc+2);
  818. +                }
  819. +             }
  820. +          }
  821. +       }
  822. + 
  823. +       if (index != INVALID) strcpy (sel_str, nameDspPtr[index]);
  824. + 
  825. +       cfree (*nameDspPtr);
  826. +       cfree (nameDspPtr);
  827. + 
  828. +       if (index == INVALID) break;
  829. + 
  830. +       if (sel_str[strlen(sel_str)-1] == '/')
  831. +       {
  832. +          sel_str[strlen(sel_str)-1] = '\0';
  833. +          if (strcmp (sel_str, "..") == 0)
  834. +          {
  835. +             for (i = strlen(dir_name)-1; i>=0 && dir_name[i]!='/'; i--) ;
  836. +             if (i < 0)
  837. +                dir_name[0] = '\0';
  838. +             else
  839. +                dir_name[i] = '\0';
  840. +          }
  841. +          else
  842. +          {
  843. +             strcat (dir_name, "/");
  844. +             strcat (dir_name, sel_str);
  845. +          }
  846. + 
  847. +          dsp_ptr = topOfDirLinkList;
  848. +          for ( ; dsp_ptr != NULL; dsp_ptr = dsp_ptr->next) cfree (dsp_ptr);
  849. +          topOfDirLinkList = NULL;
  850. + 
  851. +          Msg ("Generating list of file names, please wait ...");
  852. +          if ((topOfDirLinkList = DirListing (dir_name)) == NULL)
  853. +          {
  854. +             *sel_str = '\0';
  855. +             break;
  856. +          }
  857. +          Msg ("");
  858. +       }
  859. +       else
  860. +          break;
  861. +    }
  862. +    if (grabbed) XUngrabKeyboard (mainDisplay, CurrentTime);
  863. + 
  864. +    sprintf (SelStr, "%s/%s", dir_name, sel_str);
  865. + 
  866. +    if (index == INVALID)
  867. +       DisplayButton (nameBaseWin, okCancelStr[1], 8, &buttonBBox[1],
  868. +             BUTTON_INVERT);
  869. +    else
  870. +       DisplayButton (nameBaseWin, okCancelStr[0], 8, &buttonBBox[0],
  871. +             BUTTON_INVERT);
  872. + 
  873. +    XDestroyWindow (mainDisplay, nameBaseWin);
  874. +    XSync (mainDisplay, FALSE);
  875. +    while (XCheckMaskEvent (mainDisplay, ExposureMask, &input)) ;
  876. +    return (index);
  877. + }
  878. + 
  879. + static
  880. + int ChooseAName (TopStr, SelStr)
  881. +    char    * TopStr, * SelStr;
  882. + {
  883. +    int            button_widths, str_width, graph_width;
  884. +    int            str_start, button_start, graph_start, index;
  885. +    int            dsp_w, dsp_h, x, y, w, h, i, len;
  886. +    XEvent        input, ev;
  887. +    int            changing = TRUE, grabbed = FALSE, name_index;
  888. +    char            buf[80], name[MAXPATHLENGTH];
  889. +    XKeyEvent        * key_ev;
  890. +    XButtonEvent        * button_ev;
  891. +    KeySym        key_sym;
  892. +    XComposeStatus    c_stat;
  893. +    XSetWindowAttributes    win_attrs;
  894. +    int            win_x, win_y, win_w, win_h, win_d, win_brdr_w;
  895. + 
  896. +    dsp_w = DisplayWidth (mainDisplay, mainScreen);
  897. +    dsp_h = DisplayHeight (mainDisplay, mainScreen);
  898. + 
  899. +    button_widths = ButtonWidth("OK", 8) + ButtonWidth("CANCEL", 8) +
  900. +          defaultFontWidth;
  901. +    str_width = defaultFontWidth * strlen (TopStr);
  902. +    graph_width = nameDspWinW + scrollBarW + 2 * brdrW;
  903. + 
  904. +    if (str_width > graph_width)
  905. +    {
  906. +       w = str_width + 4 * defaultFontWidth;
  907. +       str_start = 2 * defaultFontWidth;
  908. +       graph_start = (w - graph_width) / 2;
  909. +    }
  910. +    else
  911. +    {
  912. +       w = graph_width + 4 * defaultFontWidth;
  913. +       str_start = (w - str_width) / 2;
  914. +       graph_start = 2 * defaultFontWidth;
  915. +    }
  916. +    button_start = (w - button_widths) / 2;
  917. +    h = (8 + ITEM_DSPED) * ROW_HEIGHT;
  918. + 
  919. +    win_x = (w > dsp_w) ? 0 : (dsp_w - w)/2;
  920. +    win_y = (h > dsp_h) ? 0 : (dsp_h - h)/3;
  921. + 
  922. +    if ((nameBaseWin = XCreateSimpleWindow (mainDisplay, rootWindow,
  923. +          win_x, win_y, w, h, brdrW, myBorderPixel, myBgPixel)) == 0)
  924. +    { printf ("Could not create desired popup window!\n"); exit (-1); }
  925. + 
  926. +    XDefineCursor (mainDisplay, nameBaseWin, defaultCursor);
  927. + 
  928. +    if ((nameDspWin = XCreateSimpleWindow (mainDisplay, nameBaseWin, graph_start,
  929. +          5*ROW_HEIGHT, nameDspW, nameDspH, brdrW, myBorderPixel,
  930. +          myBgPixel)) == 0)
  931. +    { printf ("Could not create desired popup window!\n"); exit (-1); }
  932. + 
  933. +    if ((nameScrollWin = XCreateSimpleWindow (mainDisplay, nameBaseWin,
  934. +          graph_start+nameDspWinW, 5*ROW_HEIGHT, scrollBarW, nameDspH,
  935. +          brdrW, myBorderPixel, myBgPixel)) == 0)
  936. +    { printf ("Could not create desired popup scroll window!\n"); exit (-1); }
  937. + 
  938. +    win_attrs.save_under = True;
  939. +    XChangeWindowAttributes (mainDisplay, nameBaseWin, CWSaveUnder, &win_attrs);
  940. + 
  941. +    XSetTransientForHint (mainDisplay, nameBaseWin, mainWindow);
  942. + 
  943. +    XMapWindow (mainDisplay, nameBaseWin);
  944. +    XSelectInput (mainDisplay, nameBaseWin,
  945. +          KeyPressMask | ButtonPressMask | ExposureMask);
  946. + 
  947. +    XMapWindow (mainDisplay, nameDspWin);
  948. +    XSelectInput (mainDisplay, nameDspWin,
  949. +          KeyPressMask | ButtonPressMask | ExposureMask);
  950. + 
  951. +    XMapWindow (mainDisplay, nameScrollWin);
  952. +    XSelectInput (mainDisplay, nameScrollWin,
  953. +          KeyPressMask | ButtonPressMask | ExposureMask);
  954. + 
  955. +    justClicked = FALSE;
  956. + 
  957. +    Msg ("");
  958. + 
  959. +    name[0] = '\0';
  960. +    name_index = 0;
  961. +    nameMarked = INVALID;
  962. + 
  963. +    while (changing)
  964. +    {
  965.         XNextEvent (mainDisplay, &input);
  966.         if (input.type == Expose)
  967. ***************
  968. *** 426,430 ****
  969.         {
  970.            if (input.xany.window == nameBaseWin)
  971. !             RedrawNameBaseWindow (Str, str_start, button_start, w, h);
  972.            else if (input.xany.window == nameScrollWin)
  973.               RedrawNameScrollWin ();
  974. --- 1123,1128 ----
  975.         {
  976.            if (input.xany.window == nameBaseWin)
  977. !             RedrawNameBaseWindow (TopStr, name, str_start, graph_start,
  978. !                   button_start, w, h);
  979.            else if (input.xany.window == nameScrollWin)
  980.               RedrawNameScrollWin ();
  981. ***************
  982. *** 446,466 ****
  983.            XLookupString (key_ev, buf, 80, &key_sym, &c_stat);
  984.   
  985. !          if (buf[0] == '\r' || buf[0] == '\n')
  986.            {
  987. !             looping = FALSE;
  988.               index = nameMarked;
  989.            }
  990. !          else if (buf[0] == '\033')
  991.            {
  992. !             looping = FALSE;
  993.               index = INVALID;
  994.            }
  995.            else if (key_sym>='\040' && key_sym<='\177')
  996.            {
  997.               if (buf[0] == '$')
  998.                  i = (nameEntries == 0) ? 0 : nameEntries-1;
  999.               else
  1000.                  for (i = 0; i < nameEntries; i++)
  1001. !                   if (*nameDspPtr[i] == buf[0]) break;
  1002.               if (i < nameEntries)
  1003.               {
  1004. --- 1144,1202 ----
  1005.            XLookupString (key_ev, buf, 80, &key_sym, &c_stat);
  1006.   
  1007. !          if ((buf[0]=='\r' && (key_sym & 0xff)=='\r') ||
  1008. !              (buf[0]=='\n' && (key_sym & 0xff)=='\n'))
  1009.            {
  1010. !             changing = FALSE;
  1011.               index = nameMarked;
  1012.            }
  1013. !          else if (buf[0]=='\033' && (key_sym & 0xff)=='\033')
  1014.            {
  1015. !             changing = FALSE;
  1016.               index = INVALID;
  1017.            }
  1018. +          else if (buf[0] == '\b' || buf[0] == '\177')
  1019. +          {
  1020. +             if (name_index != 0)
  1021. +             {
  1022. +                name[--name_index] = '\0';
  1023. +                for (i = 0; i < nameEntries; i++)
  1024. +                   if (strncmp (nameDspPtr[i], name, name_index) == 0)
  1025. +                      break;
  1026. + 
  1027. +                if (i < nameEntries)
  1028. +                {
  1029. +                   if (i < nameFirst)
  1030. +                      nameFirst = i;
  1031. +                   else if (i >= nameFirst+ITEM_DSPED)
  1032. +                   {
  1033. +                      if (i < nameEntries-ITEM_DSPED)
  1034. +                         nameFirst = i;
  1035. +                      else
  1036. +                         nameFirst = nameEntries-ITEM_DSPED;
  1037. +                   }
  1038. +                   nameMarked = i;
  1039. +                   RedrawNamePath (name, graph_start,
  1040. +                         3*ROW_HEIGHT+defaultFontAsc+2);
  1041. +                   RedrawNameScrollWin ();
  1042. +                   RedrawDspWindow ();
  1043. +                }
  1044. +             }
  1045. +          }
  1046.            else if (key_sym>='\040' && key_sym<='\177')
  1047.            {
  1048.               if (buf[0] == '$')
  1049. +             {
  1050.                  i = (nameEntries == 0) ? 0 : nameEntries-1;
  1051. +                strcpy (name, nameDspPtr[i]);
  1052. +             }
  1053.               else
  1054. +             {
  1055. +                name[name_index++] = buf[0];
  1056. +                name[name_index] = '\0';
  1057.                  for (i = 0; i < nameEntries; i++)
  1058. !                   if (strncmp (nameDspPtr[i], name, name_index) == 0)
  1059. !                      break;
  1060. !             }
  1061. ! 
  1062.               if (i < nameEntries)
  1063.               {
  1064. ***************
  1065. *** 475,481 ****
  1066. --- 1211,1222 ----
  1067.                  }
  1068.                  nameMarked = i;
  1069. + 
  1070. +                RedrawNamePath (name, graph_start,
  1071. +                      3*ROW_HEIGHT+defaultFontAsc+2);
  1072.                  RedrawNameScrollWin ();
  1073.                  RedrawDspWindow ();
  1074.               }
  1075. +             else
  1076. +                name[--name_index] = '\0';
  1077.            }
  1078.         }
  1079. ***************
  1080. *** 487,491 ****
  1081.               if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[0]))
  1082.               {
  1083. !                looping = FALSE;
  1084.                  index = nameMarked;
  1085.               }
  1086. --- 1228,1232 ----
  1087.               if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[0]))
  1088.               {
  1089. !                changing = FALSE;
  1090.                  index = nameMarked;
  1091.               }
  1092. ***************
  1093. *** 492,496 ****
  1094.               else if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[1]))
  1095.               {
  1096. !                looping = FALSE;
  1097.                  index = INVALID;
  1098.               }
  1099. --- 1233,1237 ----
  1100.               else if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[1]))
  1101.               {
  1102. !                changing = FALSE;
  1103.                  index = INVALID;
  1104.               }
  1105. ***************
  1106. *** 502,508 ****
  1107.               if (NameDspHandler (button_ev) != INVALID)
  1108.               {
  1109. !                looping = FALSE;
  1110.                  index = nameMarked;
  1111.               }
  1112.            }
  1113.         }
  1114. --- 1243,1256 ----
  1115.               if (NameDspHandler (button_ev) != INVALID)
  1116.               {
  1117. !                changing = FALSE;
  1118.                  index = nameMarked;
  1119.               }
  1120. +             else if (nameMarked != INVALID)
  1121. +             {
  1122. +                strcpy (name, nameDspPtr[nameMarked]);
  1123. +                name_index = strlen (name);
  1124. +                RedrawNamePath (name, graph_start,
  1125. +                      3*ROW_HEIGHT+defaultFontAsc+2);
  1126. +             }
  1127.            }
  1128.         }
  1129. ***************
  1130. *** 514,519 ****
  1131. --- 1262,1270 ----
  1132.               BUTTON_INVERT);
  1133.      else
  1134. +    {
  1135. +       strcpy (SelStr, nameDspPtr[index]);
  1136.         DisplayButton (nameBaseWin, okCancelStr[0], 8, &buttonBBox[0],
  1137.               BUTTON_INVERT);
  1138. +    }
  1139.   
  1140.      XDestroyWindow (mainDisplay, nameBaseWin);
  1141. ***************
  1142. *** 523,698 ****
  1143.   }
  1144.   
  1145. ! static
  1146. ! int    LargerStr (S1, S2)
  1147. !    register char    * S1, * S2;
  1148. !    /* returns TRUE if S1 > S2 */
  1149.   {
  1150. !    while (*S1 == *S2 && *S1 != '\0' && *S2 != '\0') { S1++; S2++; }
  1151.   
  1152. !    return (*S1 > *S2);
  1153.   }
  1154.   
  1155. ! static
  1156. ! DspList * DirListing (Path, Extension, Entries)
  1157. !    char    * Path, * Extension;
  1158. !    int    * Entries;
  1159.   {
  1160. !    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  1161. !    DIR            * dirp;
  1162. !    struct direct    * d;
  1163. !    int            len, ext_len, count = 0;
  1164. !    char            ext[MAXPATHLENGTH];
  1165.   
  1166. !    if (*Path == '\0')
  1167.      {
  1168. !       if ((dirp = opendir (".")) == NULL) return (NULL);
  1169.      }
  1170.      else
  1171.      {
  1172. !       if ((dirp = opendir (Path)) == NULL) return (NULL);
  1173.      }
  1174.   
  1175. !    strcpy (ext, ".");
  1176. !    strcat (ext, Extension);
  1177. !    ext_len = strlen (ext);
  1178. !    head_ptr = tail_ptr = NULL;
  1179.   
  1180. !    while ((d = readdir (dirp)) != NULL)
  1181. !    {
  1182. !       len = strlen (d->d_name);
  1183. !       if (len > ext_len && (strcmp (ext, &d->d_name[len-ext_len]) == 0))
  1184. !       {
  1185. !          d->d_name[len-ext_len] = '\0';
  1186. !          dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  1187. !          strcpy (dsp_ptr->itemstr, d->d_name);
  1188. !          if (head_ptr == NULL)
  1189. !             head_ptr = tail_ptr = dsp_ptr;
  1190. !          else
  1191. !          {
  1192. !             p1 = NULL;
  1193. !             for (p = head_ptr; p != NULL; p = p->next)
  1194. !                if (LargerStr (d->d_name, p->itemstr))
  1195. !                   p1 = p;
  1196. !                else
  1197. !                   break;
  1198.   
  1199. !             dsp_ptr->next = p;
  1200. !             if (p == NULL)
  1201. !             {  /* dsp_ptr has the largest element */
  1202. !                tail_ptr->next = dsp_ptr;
  1203. !                tail_ptr = dsp_ptr;
  1204. !             }
  1205. !             else if (p1 == NULL)
  1206. !                head_ptr = dsp_ptr;
  1207. !             else
  1208. !                p1->next = dsp_ptr;
  1209. !          }
  1210. !          count++;
  1211.         }
  1212. !    }
  1213. ! 
  1214. !    closedir (dirp);
  1215. !    *Entries = count;
  1216. !    return (head_ptr);
  1217.   }
  1218.   
  1219. ! int SelectFileName (Extension, Str, SelStr)
  1220. !    char    * Extension, * Str, * SelStr;
  1221.   {
  1222. !    register int    i, index;
  1223. !    char        s[MAXPATHLENGTH], full_name[MAXPATHLENGTH];
  1224. !    DspList    * dsp_ptr;
  1225.   
  1226. !    sprintf (s, "Generating list of file names, please wait ...");
  1227. !    Msg (s);
  1228. !    strcpy (full_name, curDomainName);
  1229.   
  1230. !    if ((dsp_ptr = DirListing (curDomainName, Extension, &nameEntries)) == NULL)
  1231. !    {
  1232. !       strcpy (s, "No appropriate files to select from.");
  1233. !       Msg (s);
  1234. !       *SelStr = '\0';
  1235. !       return (INVALID);
  1236. !    }
  1237.   
  1238. !    nameDspPtr = MakeNameDspItemArray (nameEntries, dsp_ptr);
  1239. !    nameFirst = 0;
  1240. !    nameMarked = 0;
  1241.   
  1242. !    if ((index = Names (Str)) == INVALID)
  1243. !       *SelStr = '\0';
  1244. !    else
  1245. !       strcpy (SelStr, nameDspPtr[index]);
  1246.   
  1247. !    for ( ; dsp_ptr != NULL; dsp_ptr = dsp_ptr->next) cfree (dsp_ptr);
  1248. !    cfree (nameDspPtr[0]);
  1249. !    cfree (nameDspPtr);
  1250. ! 
  1251. !    s[0] = '\0';
  1252. !    Msg (s);
  1253. ! 
  1254. !    return (index);
  1255.   }
  1256.   
  1257.   static
  1258. ! DspList * DomainListing (Path, Entries)
  1259. !    char    * Path;
  1260.      int    * Entries;
  1261.   {
  1262. !    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  1263. !    DIR            * dirp, * dp;
  1264. !    struct direct    * d;
  1265. !    struct stat        stat_buf;
  1266. !    int            count = 0;
  1267. !    char            path[255], s[255];
  1268.   
  1269. !    if (*Path == '\0')
  1270. !       strcpy (path, ".");
  1271. !    else
  1272. !       strcpy (path, Path);
  1273.   
  1274. !    if ((dirp = opendir (path)) == NULL) return (NULL);
  1275.   
  1276. -    strcat (path, "/");
  1277.      head_ptr = tail_ptr = NULL;
  1278. ! 
  1279. !    while ((d = readdir (dirp)) != NULL)
  1280.      {
  1281. !       strcpy (s, path);
  1282. !       strcat (s, d->d_name);
  1283. ! 
  1284. !       stat (s, &stat_buf);
  1285. !       if (stat_buf.st_mode & S_IFDIR)
  1286.         {
  1287. !          dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  1288. !          strcpy (dsp_ptr->itemstr, d->d_name);
  1289. !          if (head_ptr == NULL)
  1290. !             head_ptr = tail_ptr = dsp_ptr;
  1291. !          else
  1292. !          {
  1293. !             p1 = NULL;
  1294. !             for (p = head_ptr; p != NULL; p = p->next)
  1295. !                if (LargerStr (d->d_name, p->itemstr))
  1296. !                   p1 = p;
  1297. !                else
  1298. !                   break;
  1299.   
  1300. !             dsp_ptr->next = p;
  1301. !             if (p == NULL)
  1302. !             {  /* dsp_ptr has the largest element */
  1303. !                tail_ptr->next = dsp_ptr;
  1304. !                tail_ptr = dsp_ptr;
  1305. !             }
  1306. !             else if (p1 == NULL)
  1307. !                head_ptr = dsp_ptr;
  1308.               else
  1309. !                p1->next = dsp_ptr;
  1310.            }
  1311. !          count++;
  1312.         }
  1313.      }
  1314. - 
  1315. -    closedir (dirp);
  1316. -    *Entries = count;
  1317.      return (head_ptr);
  1318.   }
  1319. --- 1274,1421 ----
  1320.   }
  1321.   
  1322. ! int SelectFileName (MsgStr, SelStr)
  1323. !    char    * MsgStr, * SelStr;
  1324.   {
  1325. !    int        index = INVALID, saved_num_dir_entries;
  1326. !    DspList    * dsp_ptr;
  1327.   
  1328. !    saved_num_dir_entries = numDirEntries;
  1329. !    if ((index = DirNames (MsgStr, SelStr)) == INVALID)
  1330. !    {
  1331. !       numDirEntries = saved_num_dir_entries;
  1332. !       dsp_ptr = topOfDirLinkList;
  1333. !       for ( ; dsp_ptr != NULL; dsp_ptr = dsp_ptr->next) cfree (dsp_ptr);
  1334. !       topOfDirLinkList = NULL;
  1335. ! 
  1336. !       *SelStr = '\0';
  1337. !       return (INVALID);
  1338. !    }
  1339. !    BuildDirList ();
  1340. !    Msg ("");
  1341. !    return (index);
  1342.   }
  1343.   
  1344. ! int SelectSymbolName (SelSymName, PathName)
  1345. !    char    * SelSymName, * PathName;
  1346.   {
  1347. !    register int    i, index = INVALID;
  1348. !    char        s[MAXPATHLENGTH], msg[MAXSTRING];
  1349. !    DspList    * dsp_ptr;
  1350.   
  1351. !    sprintf (s,
  1352. !          "Generating a list of symbol names in '%s' domain, please wait ...",
  1353. !          curDomainName);
  1354. !    Msg (s);
  1355. ! 
  1356. !    nameEntries = numSymbols;
  1357. !    nameDspPtr = MakeNameDspItemArray (nameEntries, symbolList);
  1358. !    nameFirst = 0;
  1359. !    nameMarked = 0;
  1360. ! 
  1361. !    sprintf (msg, "Please select a symbol to INSTANTIATE in the '%s' domain ...",
  1362. !          curDomainName);
  1363. !    if ((index = ChooseAName (msg, SelSymName)) == INVALID)
  1364.      {
  1365. !       *SelSymName = '\0';
  1366. !       *PathName = '\0';
  1367.      }
  1368.      else
  1369.      {
  1370. !       strcpy (SelSymName, nameDspPtr[index]);
  1371. !       strcpy (PathName, symbolList[index].pathstr);
  1372.      }
  1373. +    cfree (*nameDspPtr);
  1374. +    cfree (nameDspPtr);
  1375.   
  1376. !    Msg ("");
  1377. !    return (index);
  1378. ! }
  1379.   
  1380. ! int GetSymbolPath (SymName, PathName)
  1381. !    char    * SymName, * PathName;
  1382. ! {
  1383. !    register int    i;
  1384.   
  1385. !    for (i = 0; i < numSymbols; i++)
  1386. !       if (strcmp (SymName, symbolList[i].itemstr) == 0)
  1387. !       {
  1388. !          strcpy (PathName, symbolList[i].pathstr);
  1389. !          return (TRUE);
  1390.         }
  1391. !    return (FALSE);
  1392.   }
  1393.   
  1394. ! int NameInCurDir (FileName)
  1395. !    char    * FileName;
  1396.   {
  1397. !    register int    i;
  1398.   
  1399. !    for (i = 0; i < numDirEntries; i++)
  1400. !       if (dirList[i].directory && strcmp (FileName, dirList[i].itemstr) == 0)
  1401. !          return (TRUE);
  1402.   
  1403. !    return (FALSE);
  1404. ! }
  1405.   
  1406. ! int DirInSymPath (DirName)
  1407. !    char    * DirName;
  1408. ! {
  1409. !    register int    i;
  1410.   
  1411. !    for (i = 0; i < symPathNumEntries; i++)
  1412. !       if (strcmp (DirName, symPath[i]) == 0)
  1413. !          return (TRUE);
  1414.   
  1415. !    return (FALSE);
  1416.   }
  1417.   
  1418.   static
  1419. ! DspList * DomainListing (Entries)
  1420.      int    * Entries;
  1421.   {
  1422. !    register int    i, default_index = 0;
  1423. !    char        s[MAXSTRING], * c_ptr;
  1424. !    DspList    * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  1425.   
  1426. !    if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, "MaxDomains")) == NULL)
  1427. !       return (NULL);
  1428.   
  1429. !    *Entries = atoi (c_ptr);
  1430.   
  1431.      head_ptr = tail_ptr = NULL;
  1432. !    for (i = 0; i < *Entries; i++)
  1433.      {
  1434. !       sprintf (s, "Domain%1d", i);
  1435. !       if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, s)) == NULL)
  1436.         {
  1437. !          for ( ; head_ptr != NULL; head_ptr = head_ptr->next) cfree (head_ptr);
  1438. !          return (NULL);
  1439. !       }
  1440.   
  1441. !       dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  1442. !       strcpy (dsp_ptr->itemstr, c_ptr);
  1443. !       if (head_ptr == NULL)
  1444. !          head_ptr = tail_ptr = dsp_ptr;
  1445. !       else
  1446. !       {
  1447. !          p1 = NULL;
  1448. !          for (p = head_ptr; p != NULL; p = p->next)
  1449. !             if (LargerStr (dsp_ptr->itemstr, p->itemstr))
  1450. !                p1 = p;
  1451.               else
  1452. !                break;
  1453. ! 
  1454. !          dsp_ptr->next = p;
  1455. !          if (p == NULL)
  1456. !          {  /* dsp_ptr has the largest element */
  1457. !             tail_ptr->next = dsp_ptr;
  1458. !             tail_ptr = dsp_ptr;
  1459.            }
  1460. !          else if (p1 == NULL)
  1461. !             head_ptr = dsp_ptr;
  1462. !          else
  1463. !             p1->next = dsp_ptr;
  1464.         }
  1465.      }
  1466.      return (head_ptr);
  1467.   }
  1468. ***************
  1469. *** 701,712 ****
  1470.      char    * SelStr;
  1471.   {
  1472. !    register int        i, index;
  1473. !    char            s[MAXPATHLENGTH];
  1474. !    DspList        * dsp_ptr;
  1475.   
  1476.      Msg ("Generating list of domain names, please wait ...");
  1477.   
  1478. !    if ((dsp_ptr = DomainListing (curDomainName, &nameEntries)) == NULL)
  1479.      {
  1480.         *SelStr = '\0';
  1481.         return (INVALID);
  1482. --- 1424,1436 ----
  1483.      char    * SelStr;
  1484.   {
  1485. !    int        index;
  1486. !    char        s[MAXPATHLENGTH];
  1487. !    DspList    * dsp_ptr;
  1488.   
  1489.      Msg ("Generating list of domain names, please wait ...");
  1490.   
  1491. !    if ((dsp_ptr = DomainListing (&nameEntries)) == NULL)
  1492.      {
  1493. +       Msg ("No domain names found.");
  1494.         *SelStr = '\0';
  1495.         return (INVALID);
  1496. ***************
  1497. *** 717,721 ****
  1498.      nameMarked = 0;
  1499.   
  1500. !    if ((index = Names ("PLEASE SELECT NEW DOMAIN ...")) == INVALID)
  1501.         *SelStr = '\0';
  1502.      else
  1503. --- 1441,1445 ----
  1504.      nameMarked = 0;
  1505.   
  1506. !    if ((index = ChooseAName ("Please select a new DOMAIN ...", "")) == INVALID)
  1507.         *SelStr = '\0';
  1508.      else
  1509. ***************
  1510. *** 730,732 ****
  1511. --- 1454,1481 ----
  1512.   
  1513.      return (index);
  1514. + }
  1515. + 
  1516. + void SetCurDir (FileName)
  1517. +    char    * FileName;
  1518. + {
  1519. +    register int    i;
  1520. +    char        file_name[MAXPATHLENGTH];
  1521. + 
  1522. +    strcpy (file_name, FileName);
  1523. + 
  1524. +    for (i = strlen(file_name)-1; i>=0 && file_name[i]!='/'; i--) ;
  1525. + 
  1526. +    if (i < 0)
  1527. +    {
  1528. +       TwoLineMsg ("Error:  No '/' found in SetCurDir ().",
  1529. +                   "        curDir set to '.'.");
  1530. +       strcpy (curDir, ".");
  1531. +       strcpy (curFileName, FileName);
  1532. +    }
  1533. +    else
  1534. +    {
  1535. +       strcpy (curFileName, &file_name[i+1]);
  1536. +       file_name[i] = '\0';
  1537. +       strcpy (curDir, file_name);
  1538. +    }
  1539.   }
  1540. ---------------------------------> cut here <---------------------------------
  1541. -- 
  1542. Bill Cheng // UCLA Computer Science Department // (213) 206-7135
  1543. 3277 Boelter Hall // Los Angeles, California 90024 // USA
  1544. william@CS.UCLA.EDU      ...!{uunet|ucbvax}!cs.ucla.edu!william
  1545.  
  1546. --
  1547. Dan Heller
  1548. ------------------------------------------------
  1549. O'Reilly && Associates               Zyrcom Inc
  1550. Senior Writer                   President
  1551. argv@ora.com            argv@zipcode.com
  1552.